;	PDP-11 FLOATING POINT PACKAGE
;	INTEGER TO ASCII STRING CONVERSION
;	ASCII STRING TO INTEGER CONVERSION
;
;	MODULES INCLUDED:
;	1. ATOI
;	2. ITOA
;	3. JTOA
;
;
;
;
R0	=	%0
R1	=	%1
R2	=	%2
R3	=	%3
R4	=	%4
R5	=	%5
SP	=	%6
PC	=	%7
ATOI:	MOV	R0,-(SP)	;SAVE THE DEFA
	CLR	-(SP)		;THIS WORD IS FOR THE SWITCHES
	CLR	R2		;EVENTUALLY THE NUMBER
	CLR	R3		;WILL BE IN THIS REGISTER PAIR
	MOV	#12,R5		;DECIMAL TEN TO MULTIPLIER
	CLR	R4		;A DOUBLE PRECISION TEN AT THAT
M.AINX:	MOVB	(R1)+,R0	;GET A CHARACTER FROM THE INPUT STREAM
	BIC	#177600,R0	;CLEAR ALL BITS NOT  PART OF ASCII CODE
	CMPB	#15,R0		;COMPARE WITH <CR>
	BEQ	M.AIXT		;IF FOUND WE'RE ALL DONE
	CMPB	#54,R0		;COMPARE WITH A COMMA
	BEQ	M.AIXT		;A COMMA IS LIKE A <CR>
	CMPB	#53,R0		;IS IT A PLUS SIGN
	BEQ	M.AIPL		;BRANCH IF A PLUS
	CMPB	#55,R0		;IT COULD BE A MINUS SIGN
	BEQ	M.AIMI		;BRANCH IF A MINUS SIGN
	CMPB	#40,R0		;CHECK FOR A SPACE
	BEQ	M.AISP		;BRANCH IF A SPACE
	CMPB	#60,R0		;SEE IF IT IS IN THE RANGE FOR A DIGIT
	BGT	M.AIVS		;SET V AND EXIT IF TOO SMALL A VALUE
	CMPB	#71,R0		;UPPER BOUND TEST
	BLT	M.AIVS		;SET ERROR IF NOT IN GOOD SHAPE
	SUB	#60,R0		;REDUCE TO A BINARY VALUE
	MOV	R1,-(SP)	;SAVE THE SEFA FOR A WHILE
	MOV	R0,-(SP)	;SAVE THE CURRENT VALUE
	JSR	PC,M.DPIM	;GO AND MULTIPLY
	BIS	R0,R1		;CHECK FOR OVERFLOW
	BNE	M.AIVT		;IF ANY BITS ARE SET OVERFLOW
	ADD	(SP)+,R3	;ADD THE CURRENT DIGIT
	ADC	R2		;NO OVERFLOW HERE
	MOV	(SP)+,R1	;PICK UP THE STORED SEFA
	BIS	#1,@SP		;SET THE SIGNIFICANCE SWITCH
	BR	M.AINX		;GO GET THE NEXT CHARACTER
M.AIMI:	BIS	#10,@SP		;SET MINUS SIGN ENCOUNTERED
M.AIPL:	BIT	#5,@SP		;TEST SIGNIFICANCE AND PREVIOUS SIGN
	BNE	M.AIVS		;IF ILLEGAL EXIT NOW
	BIS	#4,@SP		;SET SIGN ENCOUNTERED
	BR	M.AINX		;GO GET MORE
M.AISP:	BIT	#1,@SP		;SPACE ENCOUNTERED TEST SIGNIFICANCE
	BEQ	M.AINX
M.AIX1:	MOVB	(R1)+,R0	;<-
	BIC	#177600,R0	;  I
	CMPB	#40,R0		;  I
	BEQ	.-12		;->
	CMPB	#15,R0		;NOT BLANK SO CHECK FOR <CR> OR COMMA
	BEQ	M.AIXT		;OK IF A <CR>
	CMPB	#54,R0		;MAYBE A COMMA?
	BEQ	M.AIXT		;OK IF IT'S A COMMA
M.AIVS:	BIC	#1,(SP)		;CLEAR CARRY
	BIS	#2,@SP		;SET THE V SWITCH
	BR	M.AIX1		;SCAN FOR A <CR> OR COMMA
M.AIXT:	TST	@SP		;IF NO SWITCHES THEN OK
	BEQ	.+10	;->	;SKIP THE SIGNIFICANCE TEST
	BIT	#1,@SP	;  I	;TEST SIGNIFICANCE SWITCH
	BEQ	M.AIVV	;  I	;EXIT WITH AN ERROR
	CMP	R2,#100000	;COMPARE HIGH ORDER FOR LIMIT
	BHI	M.AIVV		;SET V BIT ON TOO BIG A NUMBER
	BLO	M.AIX2		;IF LOW THEN OK
	TST	R3		;IF HIGH = 100000 HOW ABOUT THE LOW
	BNE	M.AIVV		;SET V IF NOT ALL EQUAL
	BIT	#10,(SP)	;SEE IF THE FUNNY NUMBER IS ALLOWED
	BEQ	M.AIVV		;SET V IF POSITIVE NUMBER
M.AIX2:	BIT	#10,@SP		;TEST FOR MINUS NUMBER
	BEQ	.+10	;->
	NEG	R2	;  I
	NEG	R3	;  I
	SBC	R2	;  I
	MOV	(SP)+,R4;<-	;SAVE THE SWITCHES FOR LATER
	MOV	(SP)+,R0	;GET THE FORGOTEN DEFA
	MOV	R3,(R0)+	;STORE THE RESULT
	MOV	R2,@R0
	CCC			;CLEAR ALL CONDITION CODES
	BIS	R4,@#177776	;SET CONDITION CODES
	RTS	PC		;AND RETURN
M.AIVT:	CMP	(SP)+,(SP)+	;POP TWI WORDS OFF THE STACK
	BR	M.AIVS		;AND SET THE ERROR RETURN
M.AIVV:	BIS	#2,@SP	;SET V
	BR	M.AIX2		;AND REENTER THE STREAM
ITOA:	MOV	R0,-(SP)	;SAVE THE DEFA
	CLR	-(SP)		;CLEAR HIGH ORDER WORD
	MOV	@R1,-(SP)	;MOVE THE WORD
	BGE	.+6	;->	;BRANCH IF HIGH ORDER BIT 0
	COM	2(SP)	;  I	;SET ALL BITS IN THE WORD
	MOV	SP,R1	;<-	;SET UP THE SEFA FOR JTOA CALL
	SUB	#14,SP		;EXPAND THE STACK FOR A DESTINATION
	MOV	SP,R0		;LET THE STACK BE THE DESTINATION
	JSR	PC,JTOA		;CALL JTOA FOR THE REAL CONVERSION
	MOV	SP,R1		;SET UP FOR A MOVE TO REAL DEFA
	MOV	20(SP),R0	;RESTORE THE USER'S DEFA
	ADD	#5,R1		;THE FIRST FIVE ARE SPACES
	MOV	#7,R2		;TOTAL OF SEVEN CHARACTERS TO BE MOVED
	MOVB	(R1)+,(R0)+	;<-	;MOVE A CHARACTER
	DEC	R2		;  I	;DECREMENT COUNTER
	BGT	.-4		;->	;BRANCH IF MORE TO DO
	ADD	#22,SP		;REMOVE ALL JUNK FORM THE STACK
	RTS	PC		;RETURN TO THE USER
JTOA:	MOV	R0,-(SP)	;SAVE THE DEFA
	CLR	-(SP)		;THIS IS A SIGN CONTROL WORD
	MOV	(R1)+,R3	;GET THE INTEGER LOW ORDER
	MOV	@R1,R2		;AND HIGH ORDER
	BGE	.+12	;->	;IF NEGATIVE
	NEG	R2	;  I	;REVERSE THE SIGN
	NEG	R3	;  I	;AND ZOT THE SIGN CONTROL
	SBC	R2	;  I	;WORD ON THE STACK
	INC	@SP	;  I
	MOV	#12,R5	;<-
	CLR	R4
	MOV	#-1,-(SP)	;A NEGITIVE NUMBER FOR LATER
M.JA01:	CLR	R0		;ZERO OUT A BUNCH OF REGISTERS
	CLR	R1
	JSR	PC,M.DPID	;DIVIDE BY TEN
	MOV	R1,-(SP)	;PUSH THE REMAINDER
	BIS	R2,R0		;PUT ALL THE BITS
	BIS	R3,R0		;IN ONE REGISTER
	TST	R0		;TEST THE QUOTIENT FOR ZERO
	BNE	M.JA01		;BRANCH IF MORE TO DO
	MOV	SP,R5		;NOW COUNT THE MUMBER OF DIGITS
	INC	R4	;<-
	TST	(R5)+	;  I	;WE HAVE A NEGATIVE NUMBER SOMEWHERE
	BGE	.-4	;->
	DEC	R4		;BE REAL ACCURATE ABOUT THIS
	MOV	#13,R3		;ELEVEN
	SUB	R4,R3		;R3 HAS THE NUMBER OF LEADING SPACES
	DEC	R3		;SAVE ROOM FOR A SIGN
	MOV	2(R5),R0	;RESTORE THE LOST DEFA
M.JA02:	TST	R3		;IS THE COUNT EXAUSTED
	BLE	M.JA03
	MOVB	#40,(R0)+	;INSERT A SPACE (ASCII 040)
	DEC	R3
	BR	M.JA02		;BACK FOR SOME MORE
M.JA03:	TST	@R5
	BEQ	M.JA04
	MOVB	#55,(R0)+	;INSERT MINUS SIGN (ASCII 055)
	BR	M.JA05
M.JA04:	MOVB	#40,(R0)+	;OR A SPACE FOR A SIGN
M.JA05:	ADD	#60,@SP	;<-	;CONVERT TO ASCII
	MOVB	(SP)+,(R0)+;  I	;MOVE TO OUTPUT AREA
	TST	@SP	;  I	;SEE IF WE ARE DONE
	BGE	.-10	;->	;BRANCH IF MORE TO DO
	MOVB	#40,@R0		;FOLLOW BY A TRAILING SPACE
	ADD	#6,SP
	RTS	PC		;RETURN TO THE USER
	.EOT
                                                                                                                                                                                                                                                                                                                                                                                                                             